home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 March - Disc 1 / Macworld (1999-03) (Disk 1).dmg / Shareware World / Utilities / Text Processing / Alpha / Tcl / Packages / modeSearchPaths.tcl < prev    next >
Encoding:
Text File  |  1998-04-28  |  10.6 KB  |  397 lines  |  [TEXT/ALFA]
  1. ## -*-Tcl-*- (install)
  2.  # ###################################################################
  3.  #    Vince's    Additions -    an extension package for Alpha
  4.  # 
  5.  #    FILE: "modeSearchPaths.tcl"
  6.  #                                      created: 3/12/96 {6:35:25 pm}    
  7.  #                                  last update: 27/4/98 {11:48:07 pm}    
  8.  #    Author:    Vince Darley
  9.  #    E-mail:    <darley@fas.harvard.edu>
  10.  #      mail:    Division of    Applied    Sciences, Harvard University
  11.  #            Oxford Street, Cambridge MA    02138, USA
  12.  #       www:    <http://www.fas.harvard.edu/~darley/>
  13.  #    
  14.  # ###################################################################
  15.  ##
  16.  
  17. alpha::extension searchPaths 1.2.1 {
  18.     menu::insert mode items 6 \
  19.       "viewSearchPath" "appendSearchPaths…" "removeSearchPaths…" "(-"
  20.     # key-binding to find and open file with selected name
  21.     newPref binding openSelection "<O<B/H" searchPaths
  22.     # key-binding to toggle from source to header file (or vice-versa)
  23.     newPref binding sourceHeaderToggle "<O/f" searchPaths
  24.     menu::insert winUtils items end \
  25.       "[menu::bind searchPathsmodeVars(sourceHeaderToggle) -]" \
  26.       "[menu::bind searchPathsmodeVars(openSelection) -]"
  27.     menu::insert global items 5 "searchPathPrefs…"
  28. # make sure we've loaded the old version of this proc
  29. auto_load file::tryToOpen
  30.  
  31. # ◊◊◊◊ Try to open the given name or selection ◊◊◊◊ #
  32. proc file::tryToOpen {{fname ""}} {
  33.     if {$fname == ""} {set fname [getSelect]}
  34.     if ![catch {file::_tryToOpen $fname ""}] {
  35.     return
  36.     }
  37.     global headerSuffices sourceSuffices
  38.     if { [file extension ${fname}] == "" } {
  39.     if ![catch {file::_tryToOpen $fname $headerSuffices}] {
  40.         return
  41.     }
  42.     if ![catch {file::_tryToOpen $fname $sourceSuffices}] {
  43.         return
  44.     }
  45.     }
  46.     if {[askyesno "'$fname' can not be found, do you wish to add an include path?"]} {
  47.     mode::appendSearchPath [get_directory]
  48.     mode::modifySearchPath
  49.     return [file::tryToOpen $fname]
  50.     }
  51.     error "Couldn't find anything"
  52. }
  53. } uninstall this-file maintainer {
  54.     "Vince Darley" darley@fas.harvard.edu <http://www.fas.harvard.edu/~darley/>
  55. } help {
  56.     Over-rides the default 'Option title-bar clicking routines',
  57.     allowing them to search more widely, and provides general 
  58.     procedures to find files from mode-specific lists of paths, 
  59.     plus handling of a new 'include paths' section of the 
  60.     'config->current mode' menu.
  61.     
  62.     By default 'opt-cmd-H' is bound to "openSelection"
  63.     and 'cmd-F2' is bound to "sourceHeaderToggle"
  64.     
  65.     You can change these items in the dialog, but you need to
  66.     restart to have the changes take effect.
  67.     
  68.     This code can also handle the creation and manipulation of
  69.     an 'search paths' menu.  You have to attach the menu to
  70.     a given mode's menu.
  71. }
  72.  
  73. proc global::searchPathPrefs {} {
  74.     global mode searchPathsmodeVars
  75.     if {$mode != ""} {
  76.         set searchPathsmodeVars(${mode}ModeSearchPath) [mode::getSearchPath]
  77.         dialog::pkg_options searchPaths
  78.         if {[set searchPathsmodeVars(${mode}ModeSearchPath)] != [mode::getSearchPath]} {
  79.             mode::setSearchPath [set searchPathsmodeVars(${mode}ModeSearchPath)]
  80.         }
  81.         unset searchPathsmodeVars(${mode}ModeSearchPath)
  82.         mode::modifySearchPath
  83.     } else {
  84.         dialog::pkg_options searchPaths
  85.     }
  86. }
  87.  
  88. # ◊◊◊◊ Include paths ◊◊◊◊ #
  89.  
  90. #################################################################
  91. #                                                                #
  92. #    Only _ever_    access include paths through these 4 functions.    #
  93. #                                                                #
  94. #################################################################
  95.  
  96. proc mode::getSearchPath {} {
  97.     global mode 
  98.     global ${mode}SearchPath
  99.     if [info exists ${mode}SearchPath] {
  100.         return [set ${mode}SearchPath]
  101.     } else {
  102.         return ""
  103.     }
  104. }
  105.  
  106. proc mode::setSearchPath {path} {
  107.     global mode 
  108.     global ${mode}SearchPath
  109.     set ${mode}SearchPath $path
  110. }
  111.  
  112. proc mode::removeSearchPath {path} {
  113.     global mode 
  114.     global ${mode}SearchPath
  115.     if [info exists ${mode}SearchPath] {
  116.         set res [lsearch -exact [set ${mode}SearchPath] $path]
  117.         if {$res != -1} {
  118.             set ${mode}SearchPath [lreplace [set ${mode}SearchPath] $res $res]
  119.         }
  120.     }
  121. }
  122.  
  123. proc mode::appendSearchPath {path} {
  124.     global mode 
  125.     global ${mode}SearchPath
  126.     lappend ${mode}SearchPath $path
  127. }
  128.  
  129. # Now we have the functions which manipulate include paths and menus
  130.  
  131. proc mode::modifySearchPath {} {
  132.     global mode modifiedVars 
  133.     if ![catch {mode::getSearchPath} include] {
  134.         lappend modifiedVars ${mode}SearchPath
  135.     }
  136.     mode::rebuildSearchPathMenu
  137. }
  138.  
  139. proc mode::rebuildSearchPathMenu {{name ""}} {
  140.     global mode
  141.     global ${mode}modeVars ${mode}SearchPathMenu
  142.     if {[info exists ${mode}modeVars(includeMenu)] \
  143.       && [set ${mode}modeVars(includeMenu)]} {
  144.         if {$name == ""} {
  145.             if [info exists ${mode}SearchPathMenu] {
  146.                 set name [set ${mode}SearchPathMenu]
  147.             } else {
  148.                 set name headers
  149.             }
  150.         } else {
  151.             set ${mode}SearchPathMenu $name
  152.         }
  153.         set paths {}
  154.         foreach p [mode::getSearchPath] {
  155.             lappend paths "[dialog::specialView_file $p]&"
  156.         }
  157.         Menu -n $name -p mode::includeProc -m [concat {
  158.             "Open"
  159.             "Add Folder…"
  160.             "Remove Folder…"
  161.             "(-"
  162.         } $paths]
  163.     }
  164. }
  165.  
  166. proc mode::checkSearchPath {} {
  167.     set    bad    0
  168.     if [catch {mode::getSearchPath}] {return [mode::appendSearchPaths]}
  169.     set    newInc {}
  170.     foreach    p [mode::getSearchPath] {
  171.         if {![file exists $p]} {
  172.             set    bad    1
  173.         } else {
  174.             lappend    newInc $p
  175.         }
  176.     }
  177.     if $bad    {
  178.         mode::setSearchPath $newInc
  179.         mode::modifySearchPath
  180.     }
  181.     return $newInc
  182. }
  183.  
  184. # Now the functions the user sees
  185.  
  186. proc mode::viewSearchPath {} {
  187.     global mode
  188.     listpick -p "Include paths for '$mode' mode:" [mode::getSearchPath]
  189. }
  190.  
  191. proc mode::removeSearchPaths {} {
  192.     global mode
  193.     set remove [listpick -p "Remove which items from '$mode' mode's search path:" -l [mode::getSearchPath]]
  194.     foreach r $remove {
  195.         mode::removeSearchPath $r
  196.     }
  197.     mode::modifySearchPath
  198. }
  199.  
  200. proc mode::appendSearchPaths {} {
  201.     if [catch {mode::getSearchPath}] {
  202.         mode::setSearchPath {}
  203.     }    
  204.     while {![catch {get_directory} path]}    {
  205.         mode::appendSearchPath $path
  206.     }
  207.     mode::modifySearchPath
  208. }
  209.  
  210. proc mode::includeProc {menu item} {
  211.     switch $item {
  212.         "Open"    {
  213.             set text [getText [lineStart [getPos]] [nextLineStart [getPos]]]
  214.             if {[regexp {["<]([^">]*)[">]} $text dummy fname]} {
  215.                 file::tryToOpen $fname
  216.             }
  217.         }
  218.         "Add Folder" { 
  219.             mode::appendSearchPath [get_directory]
  220.             mode::modifySearchPath
  221.         }
  222.         "Remove Folder" {
  223.             mode::removeSearchPath [listpick -p "Remove which folder?" [lsort [mode::getSearchPath]]]
  224.             mode::modifySearchPath
  225.         }
  226.         default {
  227.             set i [lsearch -glob [mode::getSearchPath] $item]
  228.             if {$i != -1} {
  229.                 if {[askyesno "Shall I reveal this folder in the finder?"] == "yes"} {
  230.                     openFolder [lindex [mode::getSearchPath] $i]
  231.                 }
  232.             } else {
  233.                 alertnote "Sorry, Alpha has a bug which can affect this menu.  I can't find that particular folder."
  234.             }
  235.         }
  236.         
  237.     }
  238. }
  239.  
  240. proc file::_tryToOpen {fname suffices} {
  241.     # first try basic open
  242.     if ![catch {file::_tryToOpenIn $fname [list [file dir [win::Current]]] $suffices}] {
  243.         return
  244.     }
  245.     # now try in mode include path
  246.     if ![catch {file::_tryToOpenIn $fname [mode::getSearchPath] $suffices}] {
  247.         return
  248.     }
  249.     # now try in common paths
  250.     if ![catch {file::_tryToOpenIn $fname [file::_MakeCommonPaths [file dirname [win::Current]]] $suffices}] {
  251.         return
  252.     }
  253.     
  254.     error "Couldn't find anything"
  255. }
  256.  
  257. ## 
  258.  # -------------------------------------------------------------------------
  259.  #     
  260.  #    "fileMakeCommonPaths" --
  261.  #    
  262.  #     Given a directory make    a path of common search    possibilities which
  263.  #     could pertain to that directory.  This    is done    by matching    possible
  264.  #     Source/Header directory pairs,    and    by adding the mode-dependent
  265.  #     'includePath' variable.
  266.  # -------------------------------------------------------------------------
  267.  ##
  268. proc file::_MakeCommonPaths { thisdir } {
  269.     # allow for some common possibilities of separating
  270.     # source and header files
  271.     set path [list $thisdir]
  272.     
  273.     foreach src { Source src source Src } {
  274.         if { [file tail $thisdir] == $src } {
  275.             foreach dir { Headers headers Header header } {
  276.                 lappend path [file join [file dirname $thisdir] $dir]
  277.             }
  278.             break
  279.         }
  280.     }
  281.  
  282.     foreach src { Headers headers Header header } {
  283.         if { [file tail $thisdir] == $src } {
  284.             foreach dir { Source src source Src } {
  285.                 lappend path [file join [file dirname $thisdir] $dir]
  286.             }
  287.             break
  288.         }
  289.     }
  290.  
  291.     return $path
  292. }
  293.  
  294.  
  295. proc file::_tryToOpenIn { filelist path {suffices ""}} {
  296.     set w [win::Current]
  297.     foreach dir $path {
  298.         foreach ff $filelist {
  299.             if {$suffices != ""} {
  300.                 foreach sfx $suffices {
  301.                     if {[file exists [file join $dir $ff$sfx]] && [file join $dir $ff$sfx] != $w} {
  302.                         file::openQuietly [file join $dir $ff$sfx]
  303.                         return
  304.                     }
  305.                 }
  306.             } else {
  307.                 if {[file exists [file join $dir $ff]] && [file join $dir $ff] != $w} {
  308.                     file::openQuietly [file join $dir $ff]
  309.                     return
  310.                 }                
  311.             }
  312.         }
  313.     }
  314.     error "Couldn't find anything"
  315. }
  316.  
  317.  
  318. ## 
  319.  # ----------------------------------------------------------------------
  320.  #     
  321.  #    "file::sourceHeaderToggle" --
  322.  #    
  323.  #     Toggles the front window back and forth between a header/source
  324.  #     pair. Requires    that "headerSuffices" and "sourceSuffices" be
  325.  #     defined for whatever mode it is used in.
  326.  #    
  327.  #    Side effects:
  328.  #     A different window    is (perhaps    opened)    and    uppermost
  329.  #    
  330.  # ----------------------------------------------------------------------
  331.  ##
  332. proc file::sourceHeaderToggle {} {
  333.     set ff [win::CurrentTail]
  334.     set fbase [file::baseName $ff]
  335.     set m [modeALike]
  336.     if [file::isSource $ff] {
  337.         global headerSuffices
  338.         file::_tryToOpen ${fbase} $headerSuffices
  339.     } elseif [file::isHeader $ff] {
  340.         global sourceSuffices
  341.         file::_tryToOpen ${fbase} $sourceSuffices
  342.     } else {
  343.         # don't recognise this file
  344.         beep
  345.         message "I don't recognise the file extension. Set your 'sourceSuffices' and 'headerSuffices'"
  346.         return
  347.     }
  348. }
  349.  
  350.  
  351. ## 
  352.  # ----------------------------------------------------------------------
  353.  # 
  354.  #    "openSelection"    --
  355.  # 
  356.  #     Opens the header file currently selected, or else if that
  357.  #     fails,    calls file::sourceHeaderToggle.  Each mode can have a variable
  358.  #     'includePath' defined,    in which this procedure    searches.
  359.  # 
  360.  # ----------------------------------------------------------------------
  361.  ##
  362. proc file::openSelection {} {
  363.     file::tryToOpen
  364. }
  365.  
  366. # three simple utility procedures
  367.  
  368. proc file::isHeader { filename {m ""}} {
  369.     if {$m == ""} {
  370.         global headerSuffices
  371.         set var "headerSuffices"
  372.     } else {
  373.         global dummyProc
  374.         if {[info exists dummyProc($m)]} { $dummyProc($m) }
  375.         global ${m}modeVars
  376.         set var "${m}modeVars(headerSuffices)"
  377.     }
  378.     return [lcontains $var [file extension $filename]]
  379. } 
  380.  
  381. proc file::isSource { filename {m ""}} {
  382.     if {$m == ""} {
  383.         global sourceSuffices
  384.         set var "sourceSuffices"
  385.     } else {
  386.         global dummyProc
  387.         if {[info exists dummyProc($m)]} { $dummyProc($m) }
  388.         global ${m}modeVars
  389.         set var "${m}modeVars(sourceSuffices)"
  390.     }
  391.     return [lcontains $var [file extension $filename]]
  392. }
  393.  
  394. proc file::baseName { filename } { return [file root [file tail $filename]] }
  395.  
  396.  
  397.